//给你一个区间数组 intervals ，其中 intervals[i] = [starti, endi] ，且每个 starti 都 不同 。 
//
// 区间 i 的 右侧区间 可以记作区间 j ，并满足 startj >= endi ，且 startj 最小化 。 
//
// 返回一个由每个区间 i 的 右侧区间 的最小起始位置组成的数组。如果某个区间 i 不存在对应的 右侧区间 ，则下标 i 处的值设为 -1 。 
// 
//
// 示例 1： 
//
// 
//输入：intervals = [[1,2]]
//输出：[-1]
//解释：集合中只有一个区间，所以输出-1。
// 
//
// 示例 2： 
//
// 
//输入：intervals = [[3,4],[2,3],[1,2]]
//输出：[-1,0,1]
//解释：对于 [3,4] ，没有满足条件的“右侧”区间。
//对于 [2,3] ，区间[3,4]具有最小的“右”起点;
//对于 [1,2] ，区间[2,3]具有最小的“右”起点。
// 
//
// 示例 3： 
//
// 
//输入：intervals = [[1,4],[2,3],[3,4]]
//输出：[-1,2,-1]
//解释：对于区间 [1,4] 和 [3,4] ，没有满足条件的“右侧”区间。
//对于 [2,3] ，区间 [3,4] 有最小的“右”起点。
// 
//
// 
//
// 提示： 
//
// 
// 1 <= intervals.length <= 2 * 10⁴ 
// intervals[i].length == 2 
// -10⁶ <= starti <= endi <= 10⁶ 
// 每个间隔的起点都 不相同 
// 
// Related Topics 数组 二分查找 排序 👍 112 👎 0

package leetcode.editor.cn;

import java.util.*;

public class _436_FindRightInterval {
    public static void main(String[] args) {
        Solution solution = new _436_FindRightInterval().new Solution();
        int[][] intervals = {{1, 4}, {2, 3}, {3, 4}};//-1 2 -1
//        int[][] intervals = {{4, 5}, {2, 3}, {1, 2}};
        int[] res = solution.findRightInterval(intervals);
        System.out.println(Arrays.toString(res));
    }

    class Solution {
        public int[] findRightInterval(int[][] intervals) {
            Map<Integer, Integer> map = new HashMap<>();
            for (int i = 0; i < intervals.length; i++) {
                map.put(intervals[i][0], i);
            }

            int[] res = new int[intervals.length];
            Arrays.sort(intervals, (i1, i2)->i1[0] - i2[0]);

            for (int i = 0; i < intervals.length; i++) {
                int left = 0;
                int right = intervals.length - 1;
                int target = -1;
                while (left <= right) {
                    int mid = left + (right - left) / 2;
                    if (intervals[mid][0] < intervals[i][1]) {
                        left = mid + 1;
                    } else {
                        target = map.get(intervals[mid][0]);
                        right = mid;
                    }
                }
                res[i] = target;
            }
            return res;

//            for (int[] interval : intervals) {
//                System.out.println(Arrays.toString(interval));
//            }

        }
    }

    //leetcode submit region begin(Prohibit modification and deletion)
    class Solution1 {
        public int[] findRightInterval(int[][] intervals) {
            int[] res = new int[intervals.length];

            for (int i = 0; i < intervals.length; i++) {
                int min = Integer.MAX_VALUE;
                int index = -1;
                for (int j = 0; j < intervals.length; j++) {
                    if (intervals[j][0] >= intervals[i][1] && intervals[j][0] - intervals[i][1] < min) {
                        min = intervals[j][0] - intervals[i][1];
                        index = j;
                    }
                }
                res[i] = index;
            }
            return res;
        }
    }
//leetcode submit region end(Prohibit modification and deletion)

}